package pri.zey.custom.tools;/**
 * Created by Administrator on 2016/3/16.
 */

import java.io.UnsupportedEncodingException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>类描述
 * String工具
 * >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>属性描述
 * >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>方法描述
 * isMobile(String str)---->验证是否为手机号
 * isAccount(String str)---->用户名只能是大小写字母/数字/下划线/横线/英文点,且不能只是一个或两个英文点,至少一个字符.
 * isMatches(String rgx, String res)---->正则验证 完整匹配
 * isNumber(String str)---->验证非零的正整数
 * isSpecialCharsIn(String regEx, String targetString)---->是否存在指定字符
 * isFind(String rgx, String res)---->正则验证 查找与该模式匹配的输入序列的下一个子序列
 * isFind(String rgx, String res, int start)---->正则验证 查找与该模式匹配的输入序列的下一个子序列
 * isLookingAt(String rgx, String res)---->正则验证 将从区域开头开始的输入序列与该模式匹配
 * isBlank(String str)---->str == null 或者 "" 为 true
 * notBlank(String str)---->str == null 或者 "" 为 false
 * notBlank(String... strings)---->str... == null 或者 "" 为 false
 * notNull(Object... paras)---->paras == null 或者 "" 为 false
 * UTF2GBK(String str)---->将utf-8 格式的字符传转换为 GBK
 * convertCharset(String str, String chFrom, String chTo)---->将str从字符集chFrom转换到字符集chTo
 * String getAvailStr(Object Obj)---->获得有效的字符串,即obj为空时，返回“”，不为空，则作toString操作
 * getAvailStr(Object Obj, String value)---->获得有效的字符串,即obj为空时，返回value，不为空，则作toString操作
 * getRight(String str, int count)---->返回字符串的右边的count个字符
 * sort(String[] strs)---->降序排序字符串数组
 * firstCharToUpperCase(String srcStr)---->首字母大写
 * hasString(String[] srcString, String targetString, boolean ignoreCase)---->判断某个字符串数组里是否包含有某个字符串
 */
public class Tkit {
    private final String TAG = "tool";

    /**
     * 手机号码开头：
     移动：134、135、136、137、138、139、150、151、157(TD)、158、159、187、188
     联通：130、131、132、152、155、156、185、186
     * @param str
     * @return
     */
    public boolean isMobile(String str){
        String rgx = "^((13[0-9])|(15[0-9])|(18[0-9]))\\d{8}$";
        return isMatches(rgx, str);
    }

    /**
     * 验证非零的正整数
     * @param str
     * @return
     */
    public static boolean isNumber(String str){
        String rgx = "^\\+?[1-9][0-9]*$";
        return isMatches(rgx, str);
    }

    /**
     * 是否存在指定字符
     *
     * @param regEx
     *            正则表达式
     * @param targetString
     * @return
     */
    public static boolean isSpecialCharsIn(String regEx, String targetString) {
        Pattern pattern = Pattern.compile(regEx);
        Matcher matcher = pattern.matcher(targetString);
        return matcher.find();
    }

    /**
     * 判断某个字符串数组里是否包含有某个字符串
     *
     * @param srcString
     *            String[]
     * @param targetString
     *            String
     * @param ignoreCase
     *            boolean
     * @return
     */
    public static boolean hasString(String[] srcString, String targetString, boolean ignoreCase) {
        if (srcString == null || srcString.length == 0) {
            return false;
        }
        boolean has = false;
        for (String srcString1 : srcString) {
            if (ignoreCase) {
                if (srcString1.equalsIgnoreCase(targetString)) {
                    has = true;
                    break;
                }
            } else {
                if (srcString1.equals(targetString)) {
                    has = true;
                    break;
                }
            }
        }
        return has;
    }

    /**
     * 用户名只能是大小写字母/数字/下划线/横线/英文点,且不能只是一个或两个英文点,至少一个字符.
     * @param str
     * @return
     */
    public static boolean isAccount(String str){
        String rgx = "^[a-zA-Z]\\w{5,10}$";
        return isMatches(rgx, str);
    }

    /**
     * 正则验证 完整匹配
     * @param rgx
     * @param res
     * @return
     */
    public static boolean isMatches(String rgx, String res) {
        Pattern p = Pattern.compile(rgx);
        Matcher m = p.matcher(res);
        return m.matches();
    }

    /**
     * 正则验证 查找与该模式匹配的输入序列的下一个子序列
     * @param rgx
     * @param res
     * @return
     */
    public static boolean isFind(String rgx, String res) {
        Pattern p = Pattern.compile(rgx);
        Matcher m = p.matcher(res);
        return m.find();
    }

    /**
     * 正则验证 查找与该模式匹配的输入序列的下一个子序列
     * @param rgx
     * @param res
     * @param start
     * @return
     */
    public static boolean isFind(String rgx, String res, int start) {
        Pattern p = Pattern.compile(rgx);
        Matcher m = p.matcher(res);
        return m.find(start);
    }

    /**
     * 正则验证 将从区域开头开始的输入序列与该模式匹配
     * @param rgx
     * @param res
     * @return
     */
    public static boolean isLookingAt(String rgx, String res) {
        Pattern p = Pattern.compile(rgx);
        Matcher m = p.matcher(res);
        return m.lookingAt();
    }

    /**
     * str == null 或者 "" 为 true
     */
    public static boolean isBlank(String str) {
        return str == null || "".equals(str.trim()) ? true : false;
    }

    /**
     * str == null 或者 "" 为 false
     */
    public static boolean notBlank(String str) {
        return str == null || "".equals(str.trim()) ? false : true;
    }

    /**
     * str == null 或者 "" 为 false
     * @param strings
     * @return
     */
    public static boolean notBlank(String... strings) {
        if (strings == null)
            return false;
        for (String str : strings)
            if (str == null || "".equals(str.trim()))
                return false;
        return true;
    }

    /**
     * paras == null 或者 "" 为 false
     * @param paras
     * @return
     */
    public static boolean notNull(Object... paras) {
        if (paras == null)
            return false;
        for (Object obj : paras)
            if (obj == null)
                return false;
        return true;
    }

    /**
     * 将utf-8 格式的字符传转换为 GBK
     *
     * @param str
     * @return ""
     */
    public static String UTF2GBK(String str) {
        if (str != null && str.length() > 0) {
            try {
                byte[] byteTmp = str.getBytes("utf-8");
                str = new String(byteTmp, "GBK");
            } catch (UnsupportedEncodingException e) {
                // e.printStackTrace();
                return null;
            }
        }
        return str;
    }

    /**
     * 将str从字符集chFrom转换到字符集chTo
     *
     * @param str
     * @param chFrom
     * @param chTo
     * @return str
     */
    public static String convertCharset(String str, String chFrom, String chTo) {
        if (chTo == null || chTo.trim().length() == 0) {
            return str;
        }
        if (str != null && str.length() > 0) {
            try {
                byte[] byteTmp;
                if (chFrom == null || chFrom.length() == 0) {
                    byteTmp = str.getBytes();
                } else {
                    byteTmp = str.getBytes(chFrom);
                }
                str = new String(byteTmp, chTo);
            } catch (UnsupportedEncodingException e) {
                return null;
            }
        }
        return str;
    }

    /**
     * 获得有效的字符串,即obj为空时，返回“”，不为空，则作toString操作
     *
     * @param Obj
     * @return 有效的字符串
     */
    public static String getAvailStr(Object Obj) {
        if (Obj == null) {
            return "";
        } else {
            return Obj.toString();
        }
    }

    /**
     * 获得有效的字符串,即obj为空时，返回value，不为空，则作toString操作
     *
     * @param Obj
     * @param value
     * @return 有效的字符串
     */
    public static String getAvailStr(Object Obj, String value) {
        if (Obj == null) {
            return value;
        } else {
            return Obj.toString();
        }
    }

    /**
     * 返回字符串的右边的count个字符
     *
     * @param str
     *            原字符串
     * @param count
     *            取的字符个数
     * @return 截取的字符串
     */
    public static String getRight(String str, int count) {
        return Tkit.getAvailStr(str.substring(str.length() - count, str.length()));
    }

    /**
     * 降序排序字符串数组
     *
     * @param strs
     *            An array of String
     * @return String[] the sorted array
     */
    public static String[] sort(String[] strs) {
        int i, j, len = strs.length;
        if (len <= 1) {
            return strs;
        }
        String strTmp;
        for (i = 0; i < len - 1; i++) {
            for (j = i + 1; j < len; j++) {
                if (strs[i].compareTo(strs[j]) < 0) {
                    strTmp = strs[i];
                    strs[i] = strs[j];
                    strs[j] = strTmp;
                }
            }
        }
        return strs;
    }

    /**
     * 首字母大写
     *
     * @param srcStr
     * @return
     */
    public static String firstCharToUpperCase(String srcStr) {
        return srcStr.substring(0, 1).toUpperCase().concat(srcStr.substring(1));
    }
}
